﻿//#include<stdio.h>
//int main()
//{
//	int month;
//	printf("请输入月份：");
//	scanf_s("%d", &month);
//	switch (month) {
//	case 3:
//	case 4:
//	case 5:
//		printf("春季");
//		break;
//	case 6:
//	case 7:
//	case 8:
//		printf("夏季");
//		break;
//	case 9:
//	case 10:
//	case 11:
//		printf("秋季");
//		break;
//	case 12:
//	case 1:
//	case 2:
//		printf("冬季");
//		break;
//	default:
//		printf("输入无效");
//
//		int n = 1;
//		while (n <= 10)
//		{
//			printf("%d\n", n);
//			n++;
//		}   //while循环
//			//int i = 0;
//			//scanf_s("%d", &i);
//			//while (i)
//			//{
//			//	printf("%d", i % 10);
//			//	i /= 10;    //while循环打印4321
//			//}
//		int a = 1;
//		for (a = 1; a <= 10; a++)
//		{
//			printf("%d\n", a);
//		}  //for循环打印12345678910
//
//		int i = 0;
//		int sum = 0;
//		for (i = 3; i <= 100; i += 3)
//		{
//			sum += i;
//		}
//		printf("%d\n", sum);
//		return 0;
//}

//int main()
//{
//	int i = 0;
//	for (i = 100; i <= 200; i++)
//	{
//		int j = 0;
//		int flag = 1;
//		for (j = 2; j <= i - 1; j++)
//		{
//			if (i % j == 0)
//			{
//				flag = 0;
//				break;
//			}
//		}
//		if (flag == 1)
//			printf("%d\n", i);//求100到200的素数
//	}
//
//	int n = 0;
//	for (n = 101;n <= 200; n+=2)
//	{
//		int j = 0;
//		int flag = 1;
//		for (j = 2; j <= n - 1; j++)
//		{
//			if (n % j == 0)
//			{
//				flag = 0;
//				break;
//			}
//		}
//		if (flag == 1)
//			printf("%d\n", n);//求100到200的奇数中的素数
//
//     
//
//	}
//	printf("hh\n");
//	goto next;
//	printf("aa\n");
//next:
//	printf("已跳过aa\n");
//	
//
//	int num = 0;
//	printf("请输入数字：\n");
//	scanf_s("%d", &num);
//	int shuwei = 0;
//	do
//	{
//		num /= 10;
//		shuwei++;
//	} while (num);
//	printf("%d\n", shuwei);  //判断位数
//	printf("hello world");
//	return 0;
////}
//#include<stdio.h>
//#include<stdlib.h>
//#include<time.h>
//
//void menu()
//{
//	printf("*********************\n");
//	printf("***    1.play     ***\n");
//	printf("***    0.exit     ***\n");
//	printf("*********************\n");
//}
//void game()
//{
//	int r = rand() % 100 + 1;
//	int guess = 0;
//	system("cls");
//	int count = 5;
//	while (count)
//	{
//		printf("你有%d次机会~\n", count);
//		printf("猜猜数字");
//		scanf_s("%d", &guess);
//		if (guess > r)
//		{
//			printf("猜大了\n");
//		}
//		else if (guess < r)
//		{
//			printf("猜小了\n");
//		}
//		else
//		{
//			printf("恭喜你，猜对了\n");
//			break;
//		}
//		count--;
//		if (count == 0)
//		{
//			printf("5次机会已使用完，游戏失败\n");
//			printf("正确的数字是:%d", r);
//		}
//	}
//}
//
//int main()
//{
//	int input = 0;
//	srand((unsigned int)time(NULL));
//
//	do
//	{
//		menu();//打印菜单
//		printf("请选择>>>");
//		scanf_s("%d", &input);
//		switch (input)
//		{
//		case 1:
//			game();
//			break;
//		case 0:
//			printf("游戏结束，退出游戏\n");
//			break;
//		default:
//			printf("选择错误\n");
//			break;
//		}
//
//	} while (input);
//
//
//		return 0;   //猜数字游戏
//}

//#include<stdio.h>
//#include<windows.h>
//#include<stdlib.h>
//
//
//int main()
//{
//	char arr1[] = "welcome to code world!!!!!!!!!";
//	char arr2[] = "******************************";
//	int left = 0;
//	int right = strlen(arr1) - 1;
//	while (left <= right)
//	{
//		arr2[left] = arr1[left];
//		arr2[right] = arr1[right];
//		printf("%s\n", arr2);
//		Sleep(1000); //单位为ms
//		system("cls");
//		left++;
//		right--;
//	}
//	printf("welcome to code world!!!!!!!!!");
//	return 0;
//}
//
//#include<stdio.h>

//int main()
//{
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int n = 0;
//	scanf_s("%d", &n);//要查找的数字
//	 
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int left = 0;
//	int right = sz - 1;
//	int flag = 0;//找不到的时候
//	while (left <= right)
//	{
//		int mid = (left + right) / 2;  //可替换为 int mid = left + (right-left)/2   更加全面
//		if (arr[mid] < n)
//		{
//			left = mid + 1;
//		}
//		else if (arr[mid] > n)
//		{
//			right = mid - 1;
//		}
//		else
//			printf("找到了，下标是：%d\n", mid);
//		flag = 1;
//		break;
//	}
//	if (flag = 0)
//		printf("找不到\n");  
//	return 0;      //二分查找
//}

//#include<stdio.h>
//int main()
//{
//	char upper;
//	printf("请输入一个大写字母：");
//	//
//	scanf_s("%c", &upper,1);
//	char lower = upper + 32;
//	printf("对应的小写字母是：%c\n", lower);
//
//	return 0;
//}



//#include<stdio.h>
//int main()
//{
//	int num;
//	printf("请输入一个数字：");
//	scanf_s("%d", &num);
//	printf("这个数字的八进制输出为：%o\n", num);
//	printf("这个数字的十六进制小写输出为：%x\n", num);
//	printf("这个数字的十六进制大写输出为：%X\n", num);
//	return 0;
//}

//
//#include<stdio.h>
//
//int is_leap_year(int x)
//{
//	if (((x % 4 == 0) && (x % 100 != 0)) || (x % 400 == 0))
//		return 1;
//	else
//		return 0;
//}
//int get_days_of_month(int x, int y)
//{
//	int days[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
//	int d = days[y];
//	if (is_leap_year(x) && y == 2)
//	d += 1;
//	return d;
//}
//int main()
//{
//	int year = 0;
//	int month = 0;
//	printf("请输入要查询的时间\n年份:");
//	scanf_s("%d", &year);
//	printf("月份：");
//	scanf_s("%d", &month);
//	//计算天数
//	int d = get_days_of_month(year, month);
//	printf("当月天数为：%d\n", d);
//
//	return 0;  //查询某一年某一月的天数
//}




//#include<stdio.h>
//
//
//int Mutiple(int n)
//{
//	if (n == 0)
//		return 1;
//	else
//		return Mutiple(n - 1)*n;
//}
//int main()
//{
//	int n = 0;
//	printf("请输入要求阶乘的数字：");
//	scanf_s("%d", &n);
//	int a = Mutiple(n);
//	printf("%d\n", a);
//	return  0;     / /用递归思想求阶乘，在一定范围内可以实现计算，数字过大超出了int能存储的最大值，就会发生溢出
//}



//#include<stdio.h>
//
//int Fbnq(int n)
//{
//	int a = 1;
//	int b = 1;
//	int c = 1;
//	while (n >= 3)
//	{
//		c = a + b;
//		a = b;
//		b = c;
//		n--;
//	}
//	return c;
//}
//int main()
//{
//	int n = 0;
//	printf("请输入要求的斐波那契数:");
//	scanf_f(s("%d", &n);
//	int d = Fbnq(n);
//	print"该数是：%d\n", d);     
//	return 0;    //用递归思想求斐波那契数
//
//}


//#include<stdio.h>
//int main()
//{
//	int a = 0;
//	int b = 017;
//	printf("%d\n", a);
//	printf("%d\n", b);  //%d打印的数字是十进制的
//	printf("%o\n", a);  //%o打印的数字是八进制的xf
//	printf("%x\n", a);  //%x打印的数字是十六进制的
//
//	return 0;  
//}


//#include<stdio.h>
//
//int main()
//{
//	int a = 3;
//	int b = 5;
//	printf("交换前 a=%d,b=%d\n", a, b);
//
//	a = a ^ b;
//	b = a ^ b;
//	a = a ^ b;
//	printf("交换后 a=%d,b=%d\n", a, b);
//	return 0;   //利用位操作符完成两个整数的数值交换，只能进行整数运算
//}   //位操作符利用二进制进行操作和计算，采取数值补码，&同为1为1，有0为0；|有1则为1，无1为0；^位不同为1，同为0；~补码中1变成0，0变成1；



//#include<stdio.h>
//
//int main()
//{
//	int n = 0;
//	int count = 0;
//	printf("要求的数：");
//	scanf_s("%d", &n);
//	int i = 0;
//	for (i = 0; i < 32; i++)
//	{
//		if (((n >> i) & 1) == 1)  //n>>i,因为i每次都是使用一样的补码，每求一次要多移一位
//		{
//			count++;
//		}
//	}
//	printf("count=%d\n", count);
//	//0000000000000000000000000000001  (1)
//	//n&1 == 1,说明n的二进制中最低位是1
//	//n&1 == 0.说明n的二进制中最低位是0
//	return 0;    //求n的二进制有几个1
//}      


//
//#include<stdio.h>
//
//int main()
//{
//	int n = 0;
//	int count = 0;
//	printf("要求的数：");
//	scanf_s("%d", &n);
//	while (n)
//	{
//		n = n & (n - 1);
//		count++;
//	}
//	printf("count=%d", count);
//	return 0;  //求n中有几个1，更简洁的做法
//}
//
//#define _CRT_SECURE_NO_WARNINGS
//#include<stdio.h>
//#include<string.h>
//
//struct stu
//{
//	char name[20];
//	int age;
//	char sex[15];
//	char id[15];  //储存完整长数字，这里最好用char类型，int存储整数数组需要逐个元素初始化，应为{2，0，0，7，1，2，0，9}
//
//};
//
//struct stu s1 = { "欧阳楠",17,"女","20071209"};
//struct stu s2 = { "潘奕",18,"男","20061026"};  //char带“”
//struct stu s3 = { "11",22,"33",44 };     //全局变量，如果在main函数内是局部变量
//int main()
//{
//	printf("%s\n", s1. name);
//	printf("%d\n", s1.age);
//	printf("%s\n", s1.sex);
//	printf("%s\n", s1.id);
//	s3.age = 12;
//	printf("%d\n", s3.age);    //第一种替换信息方式
//	strcpy(s3.sex, "34");
//	printf("%s\n", s3.sex);   //第二种替换信息方式，不过限于字符串，且必要时候要定义  #define _CRT_SECURE_NO_WARNINGS
//
//
//	return 0;
//}



//#include<stdio.h>
//int main()
//{
//	int a = 4;
//	int b = 127;
//	int c = a + b;
//	printf("%d\n", c);   //在int类型时正常相加，得出131的结果，int可以完整保存二进制码
//	
//	char d = 4;    //char类型不能够完整保存二进制码，因为储存空间小，数字为32字节，char只能储存8字节，会产生截断，于是有了后续提升
//	//d 00000000000000000000000000000100
//	char e = 127;
//	//e 00000000000000000000000001111111
//	char f = d + e;
//	//因为截断，在计算时d（00000100） e(01111111) 则f(10000011),此时提升至32位
//	//有符号整数提升时看符号位，无符号高位补0；于是f（11111111111111111111111110000011），这时还是原码
//	//f反码 10000000 00000000 0000000001111100
//	//f补码 1000000000000000000000000001111101
//	// -125
//	printf("%d\n", f);
//
//	int i = 0;
//	int ret = (++i) + (++i) + (++i);   //这里是先进行了三个++，再进行计算，在不同的编译器（如devc++),又是不同的计算结果，不同编译器计算顺序不一样
//	printf("%d\n", ret);    //问题表达式 不同编译器计算顺序不同
//	return 0;   //整形提升  不同编译器计算顺序
//}



//#include<stdio.h>
//int main()
//{
//	int a = 10;
//	printf("%p\n", &a);
//	int* pa = &a;   //pa仅仅是一个变量名，可以取其他名字，指针变量存放的都是地址，要用int类型存储，若用char，会导致系统报错，读取结果错误
//	*pa = 20;   //*pa就是a,可以通过*pa重新赋值
//	printf("%d\n", *pa);
//
//	int b = 10;
//	int* pb = &a;
//
//	char c = "w";
//	char* pc = &pc;
//
//	printf("%zd\n", sizeof(pb));  //8
//	printf("%zd\n", sizeof(pc));  //8
//	//这两个大小都是8，因为指针变量大小与类型无关，与64位还是32位有关
//	//在相同平台上，大小都是相同的
//
//	int d = 10;
//	int* pd = &d;     //int,char的访问权限不同
//	char* pD = &d;   //char的访问大小更小，是一个字节，int是四个字节
//
//	printf("&d = %p\n", &d);
//	printf("pd = %p\n", pd);
//	printf("pd+1 = %p\n", pd+1);
//	printf("pD = %p\n", pD);     
//	printf("pD+1 = %p\n", pD+1);    //指针类型决定了走一步走多大的距离
//	return 0;
//
//	//指针的基础知识，长度或者说大小，类型在指针中的意义
//}


//
//#include<stdio.h>
//int main()
//{
//	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
//	int * p = &arr[0];
//	int i = 0;
//	size_t sz = sizeof(arr) / sizeof(arr[0]);  //长度最好用size_t来，匹配格式
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d\n", *(p + i));  //*p+i,随着i逐渐增大，逐渐打印出arr数组里的数
//	}   //可以+1，也可以-1，只不过从前往后和从后往前的区别
//	printf("%zd\n", &arr[9] - &arr[0]); //结果是两个指针之间的元素个数
//
//	return 0;
//}


//#include<stdio.h>
//
//size_t my_strlen(char* p)
//{
//	int count = 0;
//	while (* p != 0)
//	{
//		count++;
//		p++;
//	}
//	return count;
//}
//int main()
//{
//	char arr[] = "abcdef";
//	//a b c d e f \0
//	//my_strlen函数统计、0之前的字符个数
//	size_t len =my_strlen(arr);
//	//数组传参的时候，写的是数字名
//	//数组名表示的是数字首元素的地址(arr[0]）
//	printf("%zd", len);
//	return 0;
//}


//#include<stdio.h>
//
//int main()
//{
//	//const修饰指针变量
//	int n = 10;
//	int b = 20;
//	//1.const放左边时
//	const int* p = &n;
//	//*p = 100;  //err,const放左边修饰时不能通过指针变量重新赋值
//	//p = &b;   //ok,const放左边时可以修改p的转向
//
//	int a = 10;
//	int c = 20;
//	//2.const放右边时
//	int* const pa = &a;
//	//*pa = 100;  //ok,const放右边时可以通过指针变量来重新赋值
//	//pa = &c;   //err,const放右边时不可以修改p的转向，即p本身
//
//	int d = 10;
//	int e = 20;
//	//3.两边放const时
//	const int* const pd = &a;
//	//*pd = 100;err
//	//pd = &e;err
//return 0;  //const的使用
//}






//#include<stdio.h>
//int main()
//{
//	int* p;  //局部变量未初始化，默认为随机值
//	*p = 20;  
//	printf("%d", *p);  //会报错，野指针
//}



//#include<stdio.h>
//
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int* p = &arr[0];
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		*(p++) = i;
//	}
//	//此时p已经越界，跑到10后面去了
//	p = NULL;
//	//下次使用时，判断p不为NULL时再使用
//	p = &arr[0];  //赋值操作，重新给p进行赋值，这种操作的前提是p已经是声明过的int*类型指针变量
//	if (p != NULL)
//	{
//
//	}
//	return 0;  //NULL的使用
//}
//
//
//
//
//
//
//
//
//
//#include<stdio.h>
//
//int test()
//{
//	int n = 100;
//	return &n;
//}
//
//int main()
//{
//	int* p = test();       //n为局部变量，主函数返回局部变量的地址，造成越界访问
//	printf("%d\n", *p);   //读取访问权限冲突
//	return 0;
//
//}



//#include<stdio.h>
//
//int main()
//{
//	int* p = NULL;
//	*p = 20;  //不可访问空指针，会报错，访问权限冲突
//
//	return 0;
//
//}


//#include<stdio.h>
//int main()
//{
//	int arr[10] = { 0 };
//
//	printf("arr        = %p\n", arr);   //首元素地址
//	printf("arr+1      = %p\n", arr + 1);
//
//	printf("&arr[0]    = %p\n", &arr[0]);//首元素地址
//	printf("&arr[0]+1  = %p\n", &arr[0] + 1);
//
//	printf("&arr       = %p\n", &arr); //整个数组的地址
//	printf("&arr+1     = %p\n", &arr + 1);
//	return 0;
//}


//#include<stdio.h>
//int main()
//{
//	int a = 10;
//	printf("%d", a);
//	int a = 100;
//	printf("%d", a);
//	return 0;
//}



//#include<stdio.h>
//void menu()
//{
//	printf("*************************\n");
//	printf("***** 1.add  2.sub ******\n");
//	printf("***** 3.mul  4.div ******\n");
//	printf("***** 0. exit      ******\n");
//	printf("*************************\n");
//}
//
//int Add(int x, int y)
//{
//	return x + y;
//}
//int Sub(int x, int y)
//{
//	return x - y;
//}
//
//int Mul(int x, int y)
//{
//	return x * y;
//}
//int Div(int x, int y)
//{
//	return x / y;
//}
//
//int main()
//{
//	int input = 0;
//	int x = 0;
//	int y = 0;
//	int r = 0;
//	do
//	{
//		menu();
//		printf("请选择:");
//		scanf_s("%d", &input);
//		switch (input)
//		{
//		case 1:
//			printf("请输入2个操作数:");
//			scanf_s("%d %d", &x, &y);
//			r = Add(x, y);
//			printf("r = %d\n", r);
//			break;
//		case 2:
//			printf("请输入2个操作数:");
//			scanf_s("%d %d", &x, &y);
//			r = Sub(x, y);
//			printf("r = %d\n", r);
//			break;
//		case 3:
//			printf("请输入2个操作数:");
//			scanf_s("%d %d", &x, &y);
//			r = Mul(x, y);
//			printf("r = %d\n", r);
//			break;
//		case 4:
//			printf("请输入2个操作数:");
//			scanf_s("%d %d", &x, &y);
//			r = Div(x, y);
//			printf("r = %d\n", r);
//			break;
//		case 0:
//			printf("退出计算器\n");
//			break;
//		default:
//			printf("选择错误,重新选择\n");
//			break;
//		}
//	} while (input);
//
//	return 0;
//}


//#define  _CRT_SECURE_NO_MARNINGS
//#include<stdio.h>
//void meun()
//{
//    printf("*************************\n");
//    printf("***** 1.add  2.sub ******\n");
//    printf("***** 3.mul  4.div ******\n");
//    printf("***** 0. exit      ******\n");
//    printf("*************************\n");
//}
//int add(int x, int y)
//{
//    return x + y;
//}
//int sub(int x, int y)
//{
//    return x - y;
//}
//int mul(int x, int y)
//{
//    return x * y;
//}
//int div(int x, int y)
//{
//    return x / y;
//}
//void calc(int(*pf)(int x, int y))
//{
//    int ret = 0;
//    int x, y;
//    printf("请输入操作数：");
//    scanf_s("%d %d", &x, &y);
//    ret = pf(x, y);
//    printf("ret = %d\n", ret);
//}
//int main()
//{
//    int input = 0;
//    do
//    {
//        meun();
//        printf("请选择：\n");
//        scanf_s("%d",&input);
//            switch (input)
//            {
//            case 1:
//                calc(add);
//                break;
//            case 2:
//                calc(sub);
//                break;
//            case 3:
//                calc(mul);
//                break;
//            case 4:
//                calc(div);
//                break;
//            case 0:
//                printf("程序结束\n");
//                break;
//            default:
//                printf("选择错误\n");
//                break;
//            }
//    } while (input);
//    return 0;   //回调函数应用
//}
//

//#include<stdio.h>
//
//int int_cmp(const void* p1, const void* p2)
//{
//    return (*(int*)p1 - *(int*)p2);
//}
//
//void swap(void* p1, void* p2, int size)
//{
//    int i = 0;
//    for (i = 0; i < size; i++)
//    {
//        int tmp = *((char*)p1 + i);
//        *((char*)p1 + i) = *((char*)p2 + i);
//        *((char*)p2 + i) = tmp;
//    }
//}
//void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
//{
//    int i = 0;
//    int j = 0;
//    int flag = 1;
//    for (i = 0; i < count - 1; i++)
//    {
//        for (j = 0; j < count - i - 1; j++)
//        {
//            if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
//            {
//                swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
//                flag = 0;
//            }
//        }
//        if (flag == 1)
//        {
//            break;
//        }
//        
//    }
//}
//
//    
//
//int main()
//{
//    int arr[] = { 1,3,5,7,9,4,6,8,2,0 };
//    int i = 0;
//    bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
//    for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//    {
//        printf("%d ", arr[i]);
//    }
//    printf("\n");
//
//    return 0;    //使用回调函数模拟qsort函数(冒泡排序）
//}



//#include<stdio.h>
//int main()
//{
//    int a = 10;
//    printf("%zd\n", sizeof(a));    //
//    printf("%zd\n", sizeof a);     //
//    //这两条在功能上是一样的，sizeof(a)是把a当作一个表达式来计算
//    printf("%zd\n", sizeof a + 2); //先计算sizeof a为四个字节，再加上2，结果为6
//    printf("%zd\n", sizeof(int));  //int类型，四个字节，对于数据类型，必须带括号
//    return 0;
//}


//#include <stdio.h>
//#include <string.h>
//
//int main()
//{
//	char arr1[] = "abc";//a b c \0
//	char arr2[] = { 'a', 'b', 'c' };
//	printf("%zd\n", strlen(arr1));//3
//	printf("%zd\n", strlen(arr2));//随机值
//
//	return 0;
//}


//#include<stdio.h>
//
//int main()
//{
//	printf("int类型数组\n");
//	int a[] = { 1,2,3,4 };
//	printf("%zd\n", sizeof(a));           //sizeof(数组名)，4*4=16
//	printf("%zd\n", sizeof(a + 0));       //a+0这里a就是首元素地址，+0依旧是首元素地址，大小为4/8，地址大小分环境
//	printf("%zd\n", sizeof(*a));          //a就是首元素地址，*a就是首元素，首元素大小为4
//	printf("%zd\n", sizeof(a[1]));        //计算的是第二个元素大小，为4
//	printf("%zd\n", szeof(a + 1));       //a是首元素地址，+1就是第二个元素地址，大小为4/8
//	printf("%zd\n", sizeof(&a));          //取的是数组地址，大小为4/8
//	printf("%zd\n", sizeof(*&a));         //取的是整个数组的地址，再解引用，是整个数组的大小，为16
//	printf("%zd\n", sizeof(&a + 1));      //&a取的是整个数组地址，+1跳过了整个数组，也是地址，大小为4/8
//	printf("%zd\n", sizeof(&a[0]));       //取首元素地址，4/8
//	printf("%zd\n", sizeof(&a[0] + 1));   //第二个元素地址，4/8
//
//	printf("\n");
//
//	printf("char类型数组\n");
//	char arr[] = { 'a','b','c','d','e','f' };
//	printf("%zd\n", sizeof(arr));          //取的是整个数组，大小为6
//	printf("%zd\n", sizeof(arr + 0));      //取的是数组首元素地址，4/8
//	printf("%zd\n", sizeof(*arr));         //arr是首元素地址，*arr是首元素，大小为1
//	printf("%zd\n", sizeof(arr[1]));       //计算的是第二个元素大小，为1
//	printf("%zd\n", sizeof(&arr));         //取的是数组地址，也就是首元素地址，大小为4/8
//	printf("%zd\n", sizeof(&arr + 1));     //跳过整个数组地址，4/8
//	printf("%zd\n", sizeof(&arr[0] + 1));  //第二个元素地址，4/8
//
//}

//
//#include<stdio.h>
//int main()
//{
//	char arr[] = "abcdef";                 // a,b,c,d,e,f,\0
//	printf("%zd\n", sizeof(arr));          //arr表示整个数组，计算的是整个数组的大小单位字节，7*1 = 7
//	printf("%zd\n", sizeof(arr + 0));      //arr数组首元素地址，arr+0还是首元素地址，4/8
//	printf("%zd\n", sizeof(*arr));         //arr是首元素地址，*arr是首元素，大小为1
//	printf("%zd\n", sizeof(arr[1]));       //数组第二个元素，大小为1
//	printf("%zd\n", sizeof(&arr));         //数组地址，首元素地址，4/8
//	printf("%zd\n", sizeof(&arr + 1));     //跳过整个数组。4/8
//	printf("%zd\n", sizeof(&arr[0] + 1));  //第二个元素地址，4/8
//}


//#include<stdio.h>
//
//int main()
//{
//	const char* p = "abcdef";
//	printf("%zd\n", sizeof(p));            //p是一个指针变量，大小是4/8
//	printf("%zd\n", sizeof(p + 1));        //p中存放a的地址，p+1是b的地址，4/8
//	printf("%zd\n", sizeof(*p));           //*P = 'a',1
//	printf("%zd\n", sizeof(p[0]));         //p[0] == *(p+0) == *p,1
//	printf("%zd\n", sizeof(&p));           //4/8,指针变量p的地址
//	printf("%zd\n", sizeof(&p + 1));       //4/8，跳过p的地址，依旧是地址
//	printf("%zd\n", sizeof(&p[0] + 1));    //4/8，&p[0] + 1就是b的地址
//
//	return 0;
//}


//
//#include<stdio.h>
//#include<string.h>
//
//int main()
//{
//	char arr[] = { 'a','b','c','d','e','f' };
//	printf("%zd\n", strlen(arr));          //首元素地址，随机值，一直找，直到找到\0
//	printf("%zd\n", strlen(arr + 0));      //依旧首元素地址，随机值
//	//printf("%zd\n", strlen(*arr));         //*arr是首元素，是'a'- 97,97传递给strlen函数，被当作地址
//	//可能会形成非法访问，程序会崩溃
//	//printf("%zd\n", strlen(arr[1]));       //第二个元素，‘b’- 98，同上，会崩溃
//	printf("%zd\n", strlen(&arr));           //&arr是数组的地址，虽然是数组的地址，值和首元素地址一样，strlen依旧是从第一个位置找\0,会得到随机值
//	printf("%zd\n", strlen(&arr + 1));       //从f后面开始找\0
//	printf("%zd\n", strlen(&arr[0] + 1));    //从b开始找\0   和上面相差5
//}



//#include<stdio.h>
//#include<string.h>
//
//int main()
//{
//	char arr[] = "abcdef";                   
//	printf("%zd\n", strlen(arr));            //6
//	printf("%zd\n", strlen(arr + 0));        //6
//	//printf("%zd\n", strlen(*arr));           //非法访问，可能会崩溃
//	//printf("%zd\n", strlen(arr[1]));         //同上
//	printf("%zd\n", strlen(&arr));           //6
//	printf("%zd\n", strlen(&arr + 1));       //随机值
//	printf("%zd\n", strlen(&arr[0] + 1));    //5
//	return 0;
//}



//#include<stdio.h>
//#include<string.h>
// 
//int main()
//{
//	char* p = "abcdef";
//	printf("%zd\n", strlen(p));               //6,p里面存放的是‘a’的地址        
//	printf("%zd\n", strlen(p + 1));           //5，p+1是b的地址
//	//printf("%zd\n", strlen(*p));              //非法访问，*p是‘a'
//	//printf("%zd\n", strlen(p[0]));            //效果同上
//	printf("%zd\n", strlen(&p));              //随机值，&p是p这个变量的地址
//	//strlen就是从p这块空间的起始地址开始向后找\0的
//	//p中存放的地址是不确定的，所以有没有\0，什么时候会遇到\0不知道
//	//p储存地址和指向参数是两块不同空间，不能以'abcdef'这个去观察
//	printf("%zd\n", strlen(&p + 1));
//	//p后面的地址，也是随机值
//	printf("%zd\n", strlen(&p[0] + 1));       //5
//
//	return 0;
//}



//#include<stdio.h>
//
//int main()
//{
//	int a[3][4] = { 0 };                        
//	printf("%zd\n", sizeof(a));                    // 48,整个数组
//	printf("%zd\n", sizeof(a[0][0]));              // 4，第一个元素
//	printf("%zd\n", sizeof(a[0]));                 // 16，第一行数组名，整个第一行数组的大小
//	printf("%zd\n", sizeof(a[0] + 1));             // 4/8，第二行地址
//	printf("%zd\n", sizeof(*(a[0] + 1)));          // 4,首先第一行第一个元素，再第二个元素，大小为4个字节
//	printf("%zd\n", sizeof(a + 1));                // 4/8，第二行元素地址，
//	printf("%zd\n", sizeof(*(a + 1)));             // 16，第二行数组元素
//	printf("%zd\n", sizeof(&a[0] + 1));            // 4/8，第二行数组地址
//	printf("%zd\n", sizeof(*(&a[0] + 1)));         // 16，第二行数组大小，对第二行进行解引用
//	printf("%zd\n", sizeof(*a));                   // 16，a是首元素的地址，就是第一行的地址，*a就是第一行，计算第一行大小
//	//*a == *(a+0) == a[0]
//	printf("%zd\n", sizeof(a[3]));                 // 16，没有越界访问，sizeof内部的表达式是不计算的
//	//压根不会去访问第四行，是根据a[0],a[1],去推导
//	//sizeof(int) - 4  
//	//sizeof(4 + 3) - 4   4+3依旧是int类型，大小为4个字节
//	return 0;
//}


//#include<stdio.h>
//
//int main()
//{
//	int a[5] = { 1, 2, 3, 4, 5 };
//	int* ptr = (int*)(&a + 1);     
//	//a本来是int(*)[5]类型，先转换为int*类型，&a取整个数组地址，+1跳过整个数组，此时ptr指向数组a最后元素后一位的位置
//	printf("%d,%d", *(a + 1), *(ptr - 1));
//	//*(a+1),偏移4字节，指向a[1],*(ptr - 1)向后偏移4字节，指向a[4]
//
//	//这里涉及将int(*)[5]转换为int*类型，区别在于不同维度，一个“整个数组”为单位，一个“元素”为单位	
//
//	return 0;
//}



//在X86环境下
//假设结构体的⼤⼩是20个字节
//程序输出的结果是啥？
//struct Test
//{
//	int Num;
//	char* pcName;
//	short sDate;
//	char cha[2];
//	short sBa[4];
//};
//struct Test* p = (struct Test*)0x100000;  //这里的0x100000只是一个指定的数据，可以用其他数据代替，例如0x123456
//
//int main()
//{
//	printf("%p\n", p + 0x1);    //0x是十六进制标志，说明偏移一个结构体长度
//	printf("%p\n", (unsigned long)p + 0x1); //这里转化为整数，偏移一个字节
//	printf("%p\n", (unsigned int*)p + 0x1); //转化成unsigned int*类型，偏移4个字节
//	
//	return 0;
//}
////给指针变量p定义struct Test 类型，让p知道按什么结构解读
////0x100000被强类型转换成(struct Test*),告诉编译器指针p要指向这个地址
////大概意思就是：定义一个名为p的指针，它专门指向struct Test结构体类型；同时，强制让p指向0x100000这个地址，并且从0x10000开始储存，
////并且从0x10000开始储存，要按照struct Test的结构来解读






//
//#include <stdio.h>
//int main()
//{
//	int a[3][2] = { {0,1}, {2,3}, {4,5} };
//	int* p1;
//	p1 = a[0];   
//	printf("%d\n", p1[0]);
//
//	int b[3][2] = { (0, 1), (2, 3), (4, 5) };
//	int* p2;
//	p2 = b[0];
//	printf("%d\n", p2[0]);
//	
//	return 0;
//}


//
//#include <stdio.h>
//int main()
//{
//	int a[5][5];
//	int(*p)[4];
//	p = a;
//	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
//
//	return 0;
//}




//#include <stdio.h>
//int main()
//{
//	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//	int* ptr1 = (int*)(&aa + 1);
//	int* ptr2 = (int*)(*(aa + 1));
//	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
//
//	return 0;
//}



//#include <stdio.h>
//int main()
//{
//	char* a[] = { "work","at","alibaba" };
//	char** pa = a;
//	pa++;
//	printf("%s\n", *pa);
//	return 0;
//}


//
//#include <stdio.h>
//int main()
//{
//	char* c[] = { "ENTER","NEW","POINT","FIRST" };
//	char** cp[] = { c + 3,c + 2,c + 1,c };
//	char*** cpp = cp;
//	printf("%s\n", **++cpp);
//	printf("%s\n", *-- * ++cpp + 3);
//	printf("%s\n", *cpp[-2] + 3);
//	printf("%s\n", cpp[-1][-1] + 1);
//	return 0;
//}





//#include<stdio.h>
//#include<ctype.h>
//
//int main()
//{
//	int r = isdigit('x');
//	printf("%d\n", r);
//
//	int t = islower('x');
//	printf("%d\n", t);
//
//	char arr[] = "asdfghj23dgf4hg47";
//	int i = 0;
//	int n = 0;
//	int m = 0;
//	while (arr[i] != '\0')
//	{
//		if (isdigit(arr[i]))
//		{
//			printf("%d ", arr[i]);
//			printf("%c ", arr[i]);
//			arr[i] -= 32;
//		}
//		i++;
//	}
//	printf("\n");
//	while (arr[n] != '\0')
//	{
//		if (isalpha(arr[n]))
//		{
//			printf("%c ", arr[n]);
//		}
//		n++;
//	}
//	printf("\n");
//	while (arr[m] != '\0')
//	{
//		if (islower(arr[m]))
//		{
//			arr[m] -= 32;
//		}
//		printf("%c", arr[m]);
//		m++;
//	}
//
//	
//	return 0;
//}


//#include <stdio.h>
//#include <ctype.h>
//int main()
//{
//    int i = 0;
//    char str[] = "Test String.\n";
//    char c;
//    while (str[i])
//    {
//        c = str[i];
//        if (islower(c))
//            c = toupper(c);
//        putchar(c);
//        i++;
//    }
//    return 0;
//}



////strlen模拟实现方法一
////计数器
//int my_strlen1(const char* str)
//{
//	int count = 0;
//	assert(str);
//	while (*str)
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//
//
////strlen模拟实现方法二
////指针-指针
//int my_strlen2(char* s)
//{
//	assert(*s);
//	char* p = s;
//	while (*p != '\0')
//	{
//		p++;
//	}
//	return p - s;
//}
//
//
////strlen模拟实现方法三
////递归
//int my_strlen3(const char* stt)
//{
//	assert(*stt);
//	if (*stt == '\0')
//		return 0;
//	else
//		return 1 + my_strlen3(stt + 1);
//}



//#define _CRT_SECURE_NO_WARNINGS
//#include<stdio.h>
//#include<string.h>
//#include<stddef.h>
//#include<assert.h>
//
//char* my_strcpy(char* dest,const char*src)
//{
//	assert(src != NULL);
//	assert(dest != NULL);
//	char* ret = dest;
//	while (*dest++ = *src++)
//	{
//		;                  //while循环内必须得有语句，不需要执行，';'空语句
//	}
//	return ret;           //返回目标空间的起始地址
//}
//int main()
//{
//	char arr1[] = "abcdef";
//	char arr2[20] = "xxxxxxxxxxxxxxxxx";//必须足够大，不然会报错
//	char *p = "xxxxxxxxxx";
//	strcpy(arr2, arr1);  //'\0'也会被拷贝到arr2
//	//strcpy(p, arr1);     //p是不可修改的常量，p指向的是只读内存，不可做修改
//	printf("%s\n", arr2);
//	char* m = my_strcpy(arr2, arr1);
//	printf("%s\n", m);
//
//}






//int main()
//{
//	char arr1[20] = "hello ";   //要有足够的空间
//	char arr2[] = "world";
//	strcat(arr1, arr2);
//	printf("%s\n", arr1);
//
//	char arr3[20] = "abcd\0xxxxxx";
//	char arr4[] = "myname";
//	strcat(arr3, arr4);
//	printf("%s\n", arr3);
//}

//char* my_strcat(char* dest, const char* str)
//{
//	char *ret = dest;
//	assert(dest != NULL);
//	assert(str != NULL);
//	while (*dest)
//	{
//		*dest++;
//	}
//	while (*dest++ = *str++)
//	{
//		;
//	}
//	return ret;
//}
//
//int main()
//{
//	char arr3[20] = "abcd\0xxxxxx";
//	char arr4[] = "myname";
//	my_strcat(arr3, arr4);
//	printf("%s\n", arr3);
//
//}






//int my_strcmp(const char* arr1, const char* arr2)
//{
//	assert(arr1 != NULL);
//	assert(arr2 != NULL);
//	while (*arr1 == *arr2)
//	{
//		if (*arr1 == '\0')
//			return 0;   //这时已经相等
//		arr1++;
//		arr2++;    //这里只需要他的地址，不需要他的值，只需要往后移一位，故不用*arr++
//	}
//	return *arr1 - *arr2;
//
//}
//
//int main()
//{
//	char* arr1 = "abcder";   //char arr1[] = "abcder";
//	char* arr2 = "abq";
//	int p = my_strcmp(arr1, arr2);
//	printf("%d\n", p);
//	if (p > 0)
//		printf("arr1 > arr2");
//	else if (p == 0)
//		printf("arr1 = arr2");
//	else
//		printf("arr1 < arr2");
//
//	return 0;
//}


//#define _CRT_SECURE_NO_WARNINGS
//#include<stdio.h>
//#include<string.h>
//
//int main()
//{
//	char arr1[] = "abcdefgh";
//	char arr2[] = "xxxxxxxx";
//	strncpy(arr1, arr2, 3);
//	printf("%s\n", arr1);
//
//	char arr3[20] = "abcdef";   //必须要指定足够空间，因为要追加
//	                            //不指定的话只会给刚好的空间，在这里也就是7个字节，没有多于空间来追加
//	char arr4[] = "xxxxxx";
//	strncat(arr3, arr4, 3);
//	printf("%s\n", arr3);
//
//	char* arr5 = "asdf";
//	char* arr6 = "ascv";
//	char* arr7 = "asdv";
//	int m = strncmp(arr5, arr6, 3);
//	int n = strncmp(arr5, arr7, 3);
//	printf("%d\n", m);
//	printf("%d\n", n);
//
//
//	return 0;
//}




//#include<stdio.h>
//#include<string.h>
//#include<stddef.h>
//#include<assert.h>
//
//const char* my_strstr(const char* st1, const char* st2)
//{
//	if (*st2 == '\0')
//		return st1;
//	const char* cur = st1;
//	while (*cur)
//	{
//		const char* s1 = cur;
//		const char* s2 = st2;
//		while (*s1 && *s2 && *s1 == *s2)
//		{
//			s1++;
//			s2++;
//		}
//		if (*s2 == '\0')
//			return cur;
//		cur++;
//	}
//	return NULL;
//
//}
//
//int main()
//{
//	char arr1[] = "abcdefgh";
//	char arr2[] = "def";
//	const char* ret = strstr(arr1, arr2);
//	if (ret == NULL)
//		printf("找不到\n");
//	else
//		printf("%s\n", ret);
//	printf("%s\n", my_strstr(arr1, arr2));
//
//	return 0;
//}


//#define _CRT_SECURE_NO_WARNINGS
//#include <stdio.h>
//#include <string.h>
//int main()
//{
//	char arr1[] = "192.444.666.999";
//	char* sep1 = ".";
//	strtok(arr1, sep1);
//	printf("%s\n", arr1);
//
//
//
//	char arr[] = "192.168.6.111";
//	char* sep = ".";
//	char* str = NULL;
//
//	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
//	{
//		printf("%s\n", str);
//	}
//	return 0;
//}


//#define _CRT_SECURE_NO_WARNINGS
//#include <errno.h>
//#include <string.h>
//#include <stdio.h>
////我们打印⼀下0~10这些错误码对应的信息
//
//int main()
//{
//	/*int i = 0;
//	for (i = 0; i <= 10; i++) 
//	{
//		printf("%s\n", strerror(i));*/
//
//	FILE* pf = fopen("test.txt", "r");
//	if (pf == NULL)
//	{
//		printf("%d\n", errno);
//		printf("hehe: %s\n", strerror(errno));
//		perror("hehe");    //这两等价
//		return 1;  //打开失败，退出程序。
//	}
//	/*}*/
//	return 0;
//}


//#define _CRT_SECURE_NO_WARNINGS
//#include<stdio.h>
//#include<string.h>
//#include<assert.h>
//
////memcpy的模拟实现
//void* my_memcpy(void* dest, void* src, size_t num)
//{
//	assert(dest && src);
//	//void*类型不能直接运算，要类型转换
//	void* ret = dest;
//	while (num--)
//	{
//		*(char*)dest = *(char*)src;
//		src =(char*)src + 1;
//		dest = (char*)dest+1;
//	}	
//	return ret;
//}
//
//int main()
//{
//	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int arr2[20] = { 0 };
//	int arr3[20] = { 0 };
//	int i = 0;
//	int n = 0;
//	memcpy(arr2, arr1, 20);
//	for (i = 0; i < 10; i++)
//	{
//		printf("%d ", arr2[i]);
//	}
//	printf("\n");
//	my_memcpy(arr3, arr1, 20);
//	for (n = 0; n < 10; n++)
//	{
//		printf("%d ", arr3[n]);
//	}
//
//	return 0;
//}




//#define _CRT_SECURE_NO_WARNINGS
//#include <stdio.h>
//#include <string.h>
//#include<assert.h>
//
//void* my_memcpy(void* dest, void* src, size_t num)
//{
//	assert(dest && src);
//	//void*类型不能直接运算，要类型转换
//	void* ret = dest;
//	while (num--)
//	{
//		*(char*)dest = *(char*)src;
//		src = (char*)src + 1;
//		dest = (char*)dest + 1;
//	}
//	return ret;
//}
//
//int main()
//{
//	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//	memmove(arr1 + 2, arr1, 20);
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		printf("%d ", arr1[i]);
//	}
//
//	return 0;
//}




//
//#define _CRT_SECURE_NO_WARNINGS
//#include <stdio.h>
//#include <string.h>
//#include<assert.h>
//
//void* my_memmove(void* dest, void* src, size_t num)
//{
//	assert(dest && src);
//	void* ret = dest;
//	//为了避免数据覆盖，分类讨论
//	if (dest < src)
//	{
//		while (num--)
//		{
//			*(char*)dest = *(char*)src;
//			dest = (char*)dest + 1;
//			src = (char*)src + 1;
//
//		}
//	}
//	else
//	{
//		while (num--)
//		{
//			*((char*)dest + num) = *((char*)src + num);
//		}
//
//	}
//	return ret;
//}
//
//int main()
//{
//	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int arr2[] = { 1,2,3,4,5,6,7,8,9,10 };
//	my_memmove(arr1, arr1 + 2, 20);
//	my_memmove(arr2 + 2,arr2, 20);
//	int n = 0;
//	int m = 0;
//	for (n = 0; n < 10; n++)
//	{
//		printf("%d", arr1[n]);
//	}
//	printf("\n");
//	for (m = 0; m < 10; m++)
//	{
//		printf("%d", arr2[m]);
//	}
//
//	return 0;
//}



//#include <stdio.h>
//#include <string.h>
//int main()
//{
//	char str[] = "hello world";
//	memset(str, 'x', 6);
//	printf(str);
//
//	printf("\n");
//
//	char str2[] = "hello world";
//	memset(str2 + 2, 'x', 6);
//	printf(str2);
//
//	return 0;
//}


//#include <stdio.h>
//#include <string.h>
//int main()
//{
//	int arr1[] = { 1,2,3,4,5 };
//	int arr2[] = { 1,2,3,4,0x12233301 };
//	int r = memcmp(arr1, arr2, 17);
//	printf("%d\n",r);
//
//	return 0;
//}

//#include<stdio.h>
//
//int main()
//{
	/*int a = 1;
	if (*(char*)&a == 1)
	{
		printf("小端");
	}
	else
	{
		printf("小端");
	}*/

	//char a = -1;
	//signed char b = -1;
	//unsigned char c = -1;
	//printf("a = %d,b = %d, c = %d", a, b, c);
	//printf("我要学好c语言");
	//printf("我要学好java\n");

	//int x, y, z, w;
	//scanf_s("%4d+%3d+%2d+%1d", &x, &y, &z, &w);
	//printf("%4d+%3d+%2d+%1d", x, y, z, w);

	


//
//	return 0;
//



//#include<stdio.h>

//int main()
//{
	//int i = 1;
	//double sum = 0.0;
	//for (i = 1; i <= 100; i++)
	//{
	//	if (i % 2 == 1)
	//	{
	//		sum += (1.0 / i);
	//	}
	//	else
	//	{
	//		sum -= (1.0 / i);
	//	}

	//}
	//printf("%lf", sum);

	
	//int i = 9;
	//int sum = 0;
	//for (i = 9; i <= 100; i += 10)
	//{
	//	sum++;
	//}
	//sum++;
	//printf("%d", sum);


	//int a, b,sum;
	//scanf_s("%d%d", &a, &b);
	//for (int i = 1; i <= a && i <= b; i++)
	//{
	//	if (a % i == 0 && b % i == 0)
	//	{
	//		sum = i;
	//	}
	//}
	//printf("%d", sum);

//}


//int bin_search(int arr[], int sz, int key)
//{
//	int left = 0;
//	int right = sz - 1;
//	while (left <= right)
//	{
//		int mid = left + (right - left) / 2;
//		if (arr[mid] == key)
//			return mid;
//		else if (arr[mid] > key)
//		{
//			right = mid - 1;
//		}
//		else
//			left = mid + 1;
//	}
//	return -1;
//}
//

//	int arr[] = { 1,2,3,4,5,6,7,8,9 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int target = 8;
//	int i = bin_search(arr, sz, target);
//	printf("%d", i);


	/*int i = 20;
	int sum = 0;
	for (i = 20; i > 1; i -= 2)
	{
		sum += 2;
		i++;
	}
	sum++;
	printf("%d", sum);*/
	/*int i, j;
	int result = 0;
	int arr[] = { 1,2,3,4,5,1,2,3,4 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		result ^= arr[i];
	}
	printf("%d", result);*/




//#include<stdio.h>
//
//int main()
//{
//	int i,j;
//	scanf_s("%d", &i);
//
//	for (j = 0; j < 31; j += 2)
//	{
//		if (i & 1 << j)
//		{
//			printf("1");
//		}
//		else
//		{
//			printf("0");
//		}
//	}
//	printf("\n");
//	for (j = 1; j < 32; j += 2)
//	{
//		if (i & 1 << j)
//			printf("1");
//		else
//			printf("0");
//	}
//
//	return 0;
//
//}


//#include<stdio.h>
//
//int main()
//{
//	int i,j,count = 0;
//	scanf_s("%d", &i);
//	for (j = 0; j < 31; j++)
//	{
//		if (i & 1 << j)
//			count++;
//	}
//	printf("%d", count);
//
//
//}


//#include<stdio.h>
//int main()
//{
//	int a = 2;
//	int b = 3;
//	printf("交换前 a = %d,b = %d\n", a, b);
//	a = a + b;
//	b = a - b;
//	a = a - b;
//	printf("交换后 a = %d,b = %d\n", a, b);
//
//	int c = 4;
//	int d = 5;
//	printf("交换前 c = %d,d = %d\n", c, d);
//	c = c ^ d;
//	d = c ^ d;
//	c = c ^ d;
//	printf("交换后 c = %d,d = %d", c, d);
//}

//#include<stdio.h>
//
//int main()
//{
//	char input,start;
//	int high,j,k,n,m;
//	scanf_s("%c", &input);
//	if (input >= 'a' && input <= 'z')
//	{
//		high = input - 'a' + 1;
//		start = 'a';
//	}
//
//	else if (input >= 'A' && input <= 'Z')
//	{
//		high = input - 'A' + 1;
//		start = 'A';
//
//	}
//	else
//	{
//		printf("输入的不是字母!\n");
//		return 0;
//	}
//	    
//	for (j = 1; j <= high; j++)
//	{
//		for (k = 1; k <= high-j; k++)
//		{
//			printf(" ");
//		}
//		for (n = 1; n <= j; n++)
//		{
//			printf("%c", start + n-1);
//
//		}
//		for (m = 1; m < j; m++)
//		{
//			printf("%c", start + j-m-1);
//		}
//		printf("\n");
//	}
//	return 0;
//}

//#include<stdio.h>
//#include<string.h>
//void print(int *arr,int len)
//{
//	int* p;
//	for (p = arr; p < arr + len; p++)  //p是int类型指针
//	{
//		printf("%d", *p);   //解引用p得到指向的arr的元素
//	}
//	printf("\n");
//}
//
//int main()
//{
//	//char *arr ="helloworld";      //这里arr是一个字符指针变量
//	//int len = strlen(arr); 
//	//for (len; len > 0; len--)
//	//{
//	//	printf("%c", *(arr + len - 1));   //这里解引用，如果不引用，那么传递给printf的就是一个地址，%c会将地址的数组解析为ASCLL值转化，打印出乱码或者无意义的字符
//	//}
//
//
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int len = sizeof(arr) / sizeof(arr[0]);
//	print(arr, len);
//
//}


#include




